 // var baseUrl = 'http://localhost:28089/'


var get = function (url, params = {}, contenType = "", method = "") {
  url = baseUrl + url; //

  return new Promise(function (resolve, reject) {
    //promise函数，具体自行百度，一两句话说不清楚
    // 网络请求发起前，显示加载动画
    wx.showLoading({
      title: '加载中'
    }); // 发起网络请求

    wx.request({
      url: url,
      //网络请求的url（接口地址）
      data: params,
      //网络请求的参数
      method: method === "PUT" ? "PUT" : "GET",
      //网络请求的类型
      header: contenType === "json" ? {
        'content-type': 'application/json'
      } : {
        'content-type': 'application/x-www-form-urlencoded'
      },
      success: function (res) {
        //网络请求成功的回调函数
        if (res.data.errCode === '-2') {
          console.log('1111111111111111111');
          setTimeout(function () {
            wx.showToast({
              title: res.data.errMsg,
              duration: 2000,
              icon: 'none'
            });
          }, 2000);
          wx.reLaunch({
            url: '/pages/login/login'
          });
        }

        resolve(res.data);
      },
      fail: err => {
        //网络请求失败的回调
        if (err.errMsg === "request:fail timeout") {
          //这里判断一个超时的情况，不是超时，统一提示数据获取失败
          wx.showToast({
            title: '请求超时',
            duration: 2000,
            icon: 'none'
          });
        } else {
          wx.showToast({
            title: '获取数据失败',
            duration: 2000,
            icon: 'none'
          });
          reject(err);
        }
      },
      complete: res => {
        //不管是失败还是成功都会执行的回调
        wx.hideLoading(); //隐藏加载动画
      }
    });
  });
}; // 封装deletes请求


var deletes = function (url, params = {}, contenType = "") {
  url = baseUrl + url;
  return new Promise(function (resolve, reject) {
    //promise函数，具体自行百度，一两句话说不清楚
    // 网络请求发起前，显示加载动画
    wx.showLoading({
      title: '加载中'
    }); // 发起网络请求

    wx.request({
      url: url,
      //网络请求的url（接口地址）
      data: params,
      //网络请求的参数
      method: "delete",
      //网络请求的类型
      header: contenType === "json" ? {
        'content-type': 'application/json'
      } : {
        'content-type': 'application/x-www-form-urlencoded'
      },
      success: function (res) {
        //网络请求成功的回调函数
        if (res.statusCode == 200) {
          //网络请求状态码，200表示接通，可进行数据操作
          resolve(res.data);
        } else {
          //否则展示对应的网络请求状态码，如500，404等等
          wx.showToast({
            title: res.statusCode,
            duration: 500
          });
        }
      },
      fail: err => {
        //网络请求失败的回调
        if (err.errMsg === "request:fail timeout") {
          //这里判断一个超时的情况，不是超时，统一提示数据获取失败
          wx.showToast({
            title: '请求超时',
            duration: 2000,
            icon: 'none'
          });
        } else {
          wx.showToast({
            title: '获取数据失败',
            duration: 2000,
            icon: 'none'
          });
          reject(err);
        }
      },
      complete: res => {
        //不管是失败还是成功都会执行的回调
        wx.hideLoading(); //隐藏加载动画
      }
    });
  });
}; // 封装post请求


var post = function (url, params = {}, contenType = "") {
  url = baseUrl + url; // var uniacid=87;
  // params.uniacid = uniacid;

  var token = wx.getStorageSync('token');
  params.token = token;
  return new Promise(function (resolve, reject) {
    //promise函数，具体自行百度，一两句话说不清楚
    // 网络请求发起前，显示加载动画
    wx.showLoading({
      title: '加载中'
    }); // 发起网络请求

    wx.request({
      url: url,
      //网络请求的url（接口地址）
      data: params,
      //网络请求的参数
      method: "POST",
      //网络请求的类型，其实这里也可以写变量，来指定不同请求类型
      //传入“json”这个字符串就是json请求头，否则是form请求头，这里甚至可以写“四元运算添加更多请求头”
      header: contenType === "json" ? {
        'content-type': 'application/json'
      } : {
        'content-type': 'application/x-www-form-urlencoded'
      },
      success: function (res) {
        resolve(res.data);
      },
      fail: err => {
        //网络请求失败的回调
        if (err.errMsg === "request:fail") {
          //这里判断一个超时的情况，不是超时，统一提示数据获取失败
          wx.showToast({
            title: '请求超时',
            duration: 2000,
            icon: 'none'
          });
        } else {
          wx.showToast({
            title: '获取数据失败',
            duration: 2000,
            icon: 'none'
          });
        }
		reject(err);
      },
      complete: res => {
        //不管是失败还是成功都会执行的回调
        wx.hideLoading(); //隐藏加载动画
      }
    });
  });
}; // 封装post请求


var post2 = function (url, params = {}, contenType = "") {
  url = baseUrlNo + url; // var uniacid=87;
  // params.uniacid = uniacid;

  return new Promise(function (resolve, reject) {
    //promise函数，具体自行百度，一两句话说不清楚
    // 网络请求发起前，显示加载动画
    wx.showLoading({
      title: '加载中'
    }); // 发起网络请求

    wx.request({
      url: url,
      //网络请求的url（接口地址）
      data: params,
      //网络请求的参数
      method: "POST",
      //网络请求的类型，其实这里也可以写变量，来指定不同请求类型
      //传入“json”这个字符串就是json请求头，否则是form请求头，这里甚至可以写“四元运算添加更多请求头”
      header: contenType === "json" ? {
        'content-type': 'application/json'
      } : {
        'content-type': 'application/x-www-form-urlencoded'
      },
      success: function (res) {
        //网络请求成功的回调函数	
        resolve(res.data);
      },
      fail: err => {
        //网络请求失败的回调
        if (err.errMsg === "request:fail timeout") {
          //这里判断一个超时的情况，不是超时，统一提示数据获取失败
          wx.showToast({
            title: '请求超时',
            duration: 2000,
            icon: 'none'
          });
        } else {
          wx.showToast({
            title: '获取数据失败',
            duration: 2000,
            icon: 'none'
          });
          reject(err);
        }
      },
      complete: res => {
        //不管是失败还是成功都会执行的回调
        wx.hideLoading(); //隐藏加载动画
      }
    });
  });
}; //封装图片上传


var upLoad = function (url, img, params = {}) {
  url = baseUrl + url;
  return new Promise(function (resolve, reject) {
    //promise函数，具体自行百度，一两句话说不清楚
    // 网络请求发起前，显示加载动画
    wx.showLoading({
      title: '加载中'
    }); // 发起网络请求

    wx.uploadFile({
      url: url,
      filePath: img,
      name: 'file',
      header: {
        "Content-Type": "multipart/form-data"
      },
      formData: params
    });
  });
}; // 封装navigateTo跳转


var navigateTo = function (url) {
  wx.navigateTo({
    url: url
  });
}; //封装跳转（销毁前一个页面，无法返回）


var redirectTo = function (url) {
  wx.redirectTo({
    url: url
  });
}; // 封装switchTab跳转


var switchTab = function (url) {
  wx.switchTab({
    url: url
  });
}; //封装navigateBack返回


var navigateBack = function (delta = Number) {
  wx.navigateBack({
    delta: delta
  });
}; // 封装uni.showModal为alert


var alert = function (msg = "", confirm, cancel) {
  //mgs是提示的内容，字符串格式；confirm,cancel要传入函数
  wx.showModal({
    title: '提示',
    //title我定义死了，如果不想叫“提示”或者自定义，可以在上面加入title变量，并在这里写入title变量
    content: msg,
    //提示的内容
    showCancel: cancel ? true : false,
    //是否显示取消按钮，如果没有传入点击取消按钮的回调函数，则不显示，否则显示
    success: res => {
      if (res.confirm) {
        //如果用户点击了确定按钮
        if (confirm) {
          //如果confirm函数不为空，则执行该函数
          confirm();
        }
      }

      if (res.cancel) {
        //如果用户点击了取消按钮
        if (cancel) {
          //如果cancel函数不为空，则执行该函数
          cancel();
        }
      }
    }
  });
};

var formatTime = function (date) {
  var year = date.getFullYear();
  var month = date.getMonth() + 1;
  var day = date.getDate();
  var hour = date.getHours();
  var minute = date.getMinutes();
  var second = date.getSeconds();
  return [year, month, day].map(formatNumber).join('-') + ' ' + [hour, minute, second].map(formatNumber).join(':');
};

var formatData = function (date) {
  var year = date.getFullYear();
  var month = date.getMonth() + 1;
  var day = date.getDate();
  return [year, month, day].map(formatNumber).join('');
};

var formatData2 = function (date) {
  var year = date.getFullYear();
  var month = date.getMonth() + 1;
  var day = date.getDate();
  return [year, month, day].map(formatNumber).join('-');
};

var formatNumber = function (n) {
  n = n.toString();
  return n[1] ? n : '0' + n;
};

var showToast = function (msg = "", icon = "") {
  wx.showToast({
    title: msg,
    duration: 2000,
    icon: icon
  });
};

var removeRepet = function (arr) {
  var replace_data = arr;
  var result = [],
      hash = {};

  for (var i = 0; i < replace_data.length; i++) {
    var elem = replace_data[i].title;

    if (!hash[elem]) {
      result.push(replace_data[i]);
      hash[elem] = true;
    }
  }

  return result;
};

function deepClone(obj) {
  var result,
      oClass = isClass(obj); //确定result的类型

  if (oClass === "Object") {
    result = {};
  } else if (oClass === "Array") {
    result = [];
  } else {
    return obj;
  }

  for (var key in obj) {
    var copy = obj[key];

    if (isClass(copy) == "Object") {
      result[key] = arguments.callee(copy); //递归调用
    } else if (isClass(copy) == "Array") {
      result[key] = arguments.callee(copy);
    } else {
      result[key] = obj[key];
    }
  }

  return result;
}

function deepClone2(data) {
  var type = typeof data;

  if (isClass(data) === Array) {
    type = 'array';
  }

  var obj;

  if (type === 'array') {
    obj = [];
  } else if (type === 'object') {
    obj = {};
  } else {
    //不再具有下一层次
    return data;
  }

  if (type === 'array') {
    for (var i = 0, len = data.length; i < len; i++) {
      console.log('hhahahahah');
      obj.push(deepClone(data[i]));
      console.log(obj);
    }
  } else if (type === 'object') {
    for (var key in data) {
      if (key === 'bottom') {
        console.log('key');
        console.log(data[key]);
      }

      obj[key] = deepClone(data[key]);
    }
  }

  return obj;
} //返回传递给他的任意对象的类


function isClass(o) {
  if (o === null) return "Null";
  if (o === undefined) return "Undefined";
  return Object.prototype.toString.call(o).slice(8, -1);
}

function sleep(numberMillis) {
  var now = new Date();
  var exitTime = now.getTime() + numberMillis;

  while (true) {
    now = new Date();
    if (now.getTime() > exitTime) return;
  }
}

module.exports = {
  formatTime,
  formatData,
  friendlyDate,
  formatData2,
  get,
  post,
  deletes,
  baseUrl,
  baseUrlNo,
  alert,
  navigateTo,
  redirectTo,
  showToast,
  switchTab,
  upLoad,
  navigateBack,
  removeRepet,
  deepClone,
  deepClone2
};